home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / kevoSource / blockfiles.c next >
Text File  |  1993-05-18  |  8KB  |  323 lines
  1. /* Kevo -- a prototype-based object-oriented language */
  2. /* (c) Antero Taivalsaari 1991-1993                   */
  3. /* Some parts (c) Antero Taivalsaari 1986-1988           */
  4. /* blockfiles.c: block file management internals      */
  5.  
  6. /* 
  7.     Traditional Forth-style block files. 
  8.     Not really needed in Kevo, but added for 
  9.     compatibility (and fun).
  10.  
  11.     Note: in the current implementation block files
  12.     are not task-specific, i.e., only one block file
  13.     shared by all tasks can be open at each time. 
  14. */
  15.  
  16. #include "global.h"
  17.  
  18. /* ----------------------------------------------------------------------- */
  19.  
  20. #define BUFFERSIZE         1024
  21. #define BUFFERAMOUNT    64
  22. #define DIRTYBIT        0x80000000
  23.  
  24. /*
  25.     Structure for keeping track of blocks that are
  26.     currently in memory.
  27. */
  28. int blockNumbers[BUFFERAMOUNT];
  29.  
  30. /*
  31.     Structure for keeping track of the addresses of buffers.
  32.     We allocate space using dynamic allocation. Initially, no
  33.     space is allocated, but when 'block' command is used new
  34.     buffers are created on the fly. Once all the buffers exist,
  35.     they will be "recycled" until deleted by 'empty-buffers'. 
  36. */
  37. char* bufferAddresses[BUFFERAMOUNT];
  38.  
  39. /* 
  40.     Variable that tells us how many buffers we have currently
  41.     in memory.
  42. */
  43. int blocksInMemory = 0;
  44.  
  45.  
  46. /* Block file pointer */
  47. FILE* blockFile;
  48.  
  49.  
  50. /* Private operations: */
  51.  
  52. /* Check if the block is in memory */
  53. /* Return the position + 1 */
  54. int blockInMemory(thisNumber)
  55. int thisNumber;
  56. {
  57.   int i;
  58.   
  59.       for (i = 0; i < blocksInMemory; i++) {
  60.           if ((blockNumbers[i] & ~DIRTYBIT) == thisNumber) return(i+1);
  61.     }
  62.     return(0);
  63. }
  64.  
  65.  
  66. /* Scroll the block numbers and buffer addresses downwards */
  67. /* starting from the given position+1 */
  68. void scrollDown(position)
  69. int position;
  70. {
  71.  int length = blocksInMemory-position;
  72.  
  73.     memmove(&blockNumbers[position],    &blockNumbers[position]+1,    length*CELL);
  74.     memmove(&bufferAddresses[position], &bufferAddresses[position]+1, length*CELL);
  75.  
  76. /* Slower implementation:
  77.   int i;
  78.   
  79.       for (i = position; i < blocksInMemory; i++) {
  80.           blockNumbers[i]    = blockNumbers[i+1];
  81.           bufferAddresses[i] = bufferAddresses[i+1];
  82.       }
  83. */
  84. }
  85.  
  86.  
  87. /* Mark the given block most recently used */
  88. void makeMostRecent(position)
  89. int position;
  90. {
  91.   int    tempNumber = blockNumbers[position];
  92.   char* tempAddress = bufferAddresses[position];
  93.  
  94.     /* If most recently used is referred to again, do nothing */
  95.     if (position == blocksInMemory-1) return;
  96.   
  97.       /* Scroll the data structures downwards */
  98.       scrollDown(position);
  99.       blockNumbers[blocksInMemory-1] = tempNumber;
  100.       bufferAddresses[blocksInMemory-1] = tempAddress;
  101. }
  102.  
  103.  
  104. void writeOntoDisk(blockNumber, bufferAddress)
  105. int   blockNumber;
  106. char* bufferAddress;
  107. {
  108.     /* Write the contents of the given buffer to given block onto disk */
  109.       if (fseek(blockFile, blockNumber*BUFFERSIZE, SEEK_SET) == 0) {
  110.           if (fwrite(bufferAddress, BUFFERSIZE, 1, blockFile) == 1) return;
  111.       }
  112.  
  113.       /* Something went wrong with writing */
  114.       fprintf(confile, "== File error (cannot write block buffer)."); showTaskID();
  115.     if (!supervisor) {
  116.         ownPrintf("-- Cannot write block buffer #%d onto disk", blockNumber);
  117.         execute((*up)->errorVector);
  118.     }
  119.     ownLongJmp();
  120. }
  121.  
  122.  
  123. /* Discard the least recently addressed buffer, 
  124.    returning its buffer address for future reuse 
  125. */
  126. char* discardLeastRecent()
  127. {
  128.   int   LRUblock = blockNumbers[0] & ~DIRTYBIT; 
  129.   char* bufferAddress = bufferAddresses[0];
  130.       
  131.       /* If the least recent block is dirty, save it onto disk */
  132.       if (blockNumbers[0] & DIRTYBIT) writeOntoDisk(LRUblock, bufferAddress);
  133.  
  134.     /* Make space in the block table */
  135.     scrollDown(0);
  136.     blocksInMemory--;
  137.     return(bufferAddress);
  138. }
  139.  
  140.  
  141. void pOpenBlockFile()
  142. {
  143.   char* fileName = (char*)popData();
  144.   FILE* file;
  145.  
  146.     if ((file = fopen(fileName, "rb+")) == NIL) {
  147.         fprintf(confile, "== File error (cannot open block file)."); showTaskID();
  148.         if (!supervisor) {
  149.             ownPrintf("-- Cannot open block file '%s'", fileName);
  150.             execute((*up)->errorVector);
  151.         }
  152.         ownLongJmp();
  153.       }
  154.       else {
  155.         /* If we have an existing block file open, close it now */
  156.           if (blockFile) pCloseBlockFile();
  157.           blockFile = file;
  158.       }    
  159. }
  160.  
  161.  
  162. void pCloseBlockFile()
  163. {
  164.     /* Save and empty the buffers first */
  165.     pSaveBuffers();
  166.     pEmptyBuffers();
  167.  
  168.     if (blockFile && fclose(blockFile)) {
  169.           fprintf(confile, "== File error (cannot close block file)."); showTaskID();
  170.         if (!supervisor) {
  171.             ownPrintf("-- Cannot close block file");
  172.             execute((*up)->errorVector);
  173.         }
  174.         ownLongJmp();
  175.     }
  176.     blockFile = NIL;
  177. }
  178.  
  179.  
  180. void pBlock()
  181. {
  182.   int   blockNumber = topData;    /* The block to be loaded */
  183.   int     position;
  184.   char* blockAddress;
  185.   
  186.       /* Check if the desired block is already in memory */
  187.       if (position = blockInMemory(blockNumber)) {
  188.           /* Return the address of that buffer */
  189.           topData = (int)bufferAddresses[position-1];
  190.         
  191.         /* Mark that block most recently used */
  192.         makeMostRecent(position-1);
  193.         yield();
  194.           return;
  195.       }
  196.   
  197.       /* Otherwise we have to load the block from file */
  198.   
  199.       /* If we already have the maximum number of blocks in memory */
  200.       /* we must discard the contents of the least recently used buffer */
  201.       if (blocksInMemory >= BUFFERAMOUNT) {
  202.           /* Keep the address of the buffer, so we don't have to */
  203.           /* worry amount memory management (reuse old buffer) */
  204.             blockAddress = discardLeastRecent();
  205.       }
  206.     /* Otherwise we have to allocate a new buffer */
  207.       else {
  208.           blockAddress = mymalloc(BUFFERSIZE);
  209.       }
  210.       
  211.       /* Load the block */
  212.       if (fseek(blockFile, blockNumber*BUFFERSIZE, SEEK_SET) == 0 && 
  213.           fread(blockAddress, BUFFERSIZE, 1, blockFile) == 1) {
  214.  
  215.           /* Successful reading: */
  216.           /* Update the block file data structure */
  217.           blockNumbers[blocksInMemory]     = blockNumber;
  218.           bufferAddresses[blocksInMemory] = blockAddress;
  219.           blocksInMemory++;
  220.               
  221.           /* Return the address to data */
  222.           topData = (int)blockAddress;
  223.       }
  224.       else {
  225.           /* Something went wrong with block access */
  226.           fprintf(confile, "== File error (cannot access block)."); showTaskID();
  227.         if (!supervisor) {
  228.             ownPrintf("-- Cannot access block #%d", blockNumber);
  229.             execute((*up)->errorVector);
  230.         }
  231.         ownLongJmp();
  232.       }
  233.     yield();
  234. }
  235.       
  236.   
  237. void pUpdate()
  238. {
  239.     /* Raise the dirty bit in the current block */
  240.     /* Dirty bit is located in the highest bit of the block number */
  241.     blockNumbers[blocksInMemory-1] |= DIRTYBIT;
  242. }
  243.  
  244.  
  245. void pDiscard()
  246. {
  247.     /* Unset the dirty bit in the current block */
  248.     blockNumbers[blocksInMemory-1] &= ~DIRTYBIT;
  249. }
  250.  
  251.  
  252. void pSaveBuffers()
  253. {
  254.   int i;
  255.   
  256.     /* Write all the dirty buffers onto disk */
  257.     /* without affecting their LRU order */
  258.  
  259.       for (i = 0; i < blocksInMemory; i++) {
  260.           int thisBlock = blockNumbers[i] & ~DIRTYBIT;
  261.  
  262.           /* If the current block is dirty, it has to be written onto disk */
  263.           if (blockNumbers[i] & DIRTYBIT) {
  264.               writeOntoDisk(thisBlock, bufferAddresses[i]);
  265.  
  266.             /* Clean the dirty bit */
  267.             blockNumbers[i] = thisBlock;
  268.         }
  269.     }
  270.     yield();
  271. }
  272.  
  273.  
  274. void pEmptyBuffers()
  275. {
  276.   int i;
  277.   
  278.     /* Empty all the buffers and release their storage space */
  279.     /* If the buffers have not been saved, changes will be lost */
  280.     
  281.     /* Release the buffers */
  282.     for (i = 0; i < blocksInMemory; i++) free(bufferAddresses[i]);
  283.  
  284.     /* Erase the block table */
  285.     blocksInMemory = 0;
  286. }
  287.  
  288.  
  289. void pMore()
  290. {
  291.   int n = popData();
  292.   int i;
  293.   
  294.     /* Allocate n more blocks to the end of the file */
  295.     /* Think C's standard function 'fseek' does not know how to expand a file */
  296.     /* -> do the same manually using 'fputc' */
  297.     fseek(blockFile, 0, SEEK_END);
  298.     for (i = 0; i < n*BUFFERSIZE; i++) {
  299.         /* Fill with zeros */
  300.         if (fputc(0, blockFile) == EOF) {
  301.               fprintf(confile, "== File error (cannot expand block file)."); showTaskID();
  302.             if (!supervisor) {
  303.                 ownPrintf("-- Unable to add more blocks to block file");
  304.                 execute((*up)->errorVector);
  305.             }
  306.             ownLongJmp();
  307.           }
  308.     }
  309.     yield();
  310. }
  311.  
  312.  
  313. void pCapacity()
  314. {
  315.   fpos_t size;
  316.   
  317.     /* Return the size of the block file (in blocks) */
  318.     fseek(blockFile, 0, SEEK_END);
  319.     fgetpos(blockFile, &size);
  320.     pushData(size/BUFFERSIZE);
  321. }
  322.  
  323.